{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Title: #How Many Apples Can You Put into the Basket"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Difficulty: #Easy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Category Title: #Algorithms"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tag Slug: #greedy #array #sorting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Name Translated: #贪心 #数组 #排序"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Solution Name: maxNumberOfApples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Translated Title: #最多可以买到的苹果数量"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Translated Content:\n",
    "<p>你有一些苹果和一个可以承载 <code>5000</code> 单位重量的篮子。</p>\n",
    "\n",
    "<p>给定一个整数数组 <code>weight</code> ，其中 <code>weight[i]</code> 是第 <code>i</code> 个苹果的重量，返回 <em>你可以放入篮子的最大苹果数量</em> 。</p>\n",
    "\n",
    "<p>&nbsp;</p>\n",
    "\n",
    "<p><strong>示例 1：</strong></p>\n",
    "\n",
    "<pre>\n",
    "<strong>输入：</strong>weight = [100,200,150,1000]\n",
    "<strong>输出：</strong>4\n",
    "<strong>解释：</strong>所有 4 个苹果都可以装进去，因为它们的重量之和为 1450。\n",
    "</pre>\n",
    "\n",
    "<p><strong>示例 2：</strong></p>\n",
    "\n",
    "<pre>\n",
    "<strong>输入：</strong>weight = [900,950,800,1000,700,800]\n",
    "<strong>输出：</strong>5\n",
    "<strong>解释：</strong>6 个苹果的总重量超过了 5000，所以我们只能从中任选 5 个。\n",
    "</pre>\n",
    "\n",
    "<p>&nbsp;</p>\n",
    "\n",
    "<p><strong>提示：</strong></p>\n",
    "\n",
    "<ul>\n",
    "\t<li><code>1 &lt;= weight.length &lt;= 10<sup>3</sup></code></li>\n",
    "\t<li><code>1 &lt;= weight[i] &lt;= 10<sup>3</sup></code></li>\n",
    "</ul>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Description: [how-many-apples-can-you-put-into-the-basket](https://leetcode.cn/problems/how-many-apples-can-you-put-into-the-basket/description/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Solutions: [how-many-apples-can-you-put-into-the-basket](https://leetcode.cn/problems/how-many-apples-can-you-put-into-the-basket/solutions/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_cases = ['[100,200,150,1000]', '[900,950,800,1000,700,800]']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "        res, n = 0, len(weight)\n",
    "        for i in range(n):\n",
    "            res += weight[i]\n",
    "            if res > 5000:\n",
    "                return i\n",
    "        return n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        n=len(weight)\n",
    "        weight.sort()   #递增排序\n",
    "        ans,r=0,5000\n",
    "        for i in range(0,n):\n",
    "            if weight[i]<=r:\n",
    "                ans+=1\n",
    "                r-=weight[i]\n",
    "            else: break\n",
    "        return ans\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "        res, cnt = 0, 0\n",
    "        for i in range(len(weight)):\n",
    "            res += weight[i]\n",
    "            cnt += 1\n",
    "            if res > 5000:\n",
    "                return cnt - 1\n",
    "        return cnt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "        res, n = 0, len(weight)\n",
    "        for i in range(n):\n",
    "            res += weight[i]\n",
    "            if res > 5000:\n",
    "                return i\n",
    "        return n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "        rem=5000\n",
    "        ret=0\n",
    "        for w in weight:\n",
    "            if rem>=w:\n",
    "                rem-=w\n",
    "                ret+=1\n",
    "            else:\n",
    "                break\n",
    "        return ret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "      weight.sort()\n",
    "      prev = 0\n",
    "      for i, w in enumerate(weight):\n",
    "        if prev + w > 5000:\n",
    "          return i\n",
    "        prev += w\n",
    "      return len(weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "        ans = 0\n",
    "        usable_weight = 5000\n",
    "        for w in weight:\n",
    "            if usable_weight >= w:\n",
    "                ans += 1\n",
    "                usable_weight -= w\n",
    "            else:\n",
    "                break\n",
    "        return ans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "        #print(weight)\n",
    "        sum=0\n",
    "        cnt=0\n",
    "        for i in weight:\n",
    "            if(sum+i<=5000):\n",
    "                sum+=i\n",
    "                cnt+=1\n",
    "        return cnt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "        res = 0\n",
    "        for i in range(len(weight)):\n",
    "            res += weight[i]\n",
    "            if res > 5000:\n",
    "                return i\n",
    "        return len(weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "        res = 0\n",
    "        for i in range(len(weight)):\n",
    "            res += weight[i]\n",
    "            if res > 5000:\n",
    "                return i\n",
    "        return len(weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        a = sorted(weight)\n",
    "        w = 0\n",
    "        n = 0\n",
    "        for i in range(len(a)):\n",
    "            if w + a[i] <= 5000:\n",
    "                w += a[i]\n",
    "                n += 1\n",
    "        return n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        total = 5000\n",
    "        weight.sort()\n",
    "        for i, w in enumerate(weight):\n",
    "            total -= w\n",
    "            if total < 0:\n",
    "                break\n",
    "        return i if total < 0 else i + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "\n",
    "        n=len(weight)\n",
    "        cnt=0\n",
    "        for i,v in enumerate(weight):\n",
    "            \n",
    "            if cnt+v<=5000:\n",
    "                cnt=cnt+v\n",
    "            else:\n",
    "                return i\n",
    "        \n",
    "        return n "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "        sum = 0\n",
    "        for i in range(len(weight)):\n",
    "            sum += weight[i]\n",
    "            if sum > 5000:\n",
    "                return i\n",
    "            elif sum == 5000:\n",
    "                return i + 1\n",
    "        else:\n",
    "            return len(weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "        total=0\n",
    "\n",
    "        for i in range(len(weight)):\n",
    "            total+=weight[i]\n",
    "            if total > 5000:\n",
    "                return i\n",
    "        return len(weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        print(len(weight))\n",
    "        weight.sort()\n",
    "        res = 5000\n",
    "        for i in range(len(weight)):\n",
    "            res -= weight[i]\n",
    "            if res < 0:\n",
    "                break\n",
    "        if i == len(weight) - 1 and res >= 0:\n",
    "            i += 1 \n",
    "        return i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        sum = 0\n",
    "        count = 0\n",
    "        for i in sorted(weight):\n",
    "            sum += i\n",
    "            if sum > 5000:\n",
    "                break\n",
    "             \n",
    "            count += 1\n",
    "        return count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "        s = 0\n",
    "        for i, x in enumerate(weight):\n",
    "            s += x\n",
    "            if s > 5000:\n",
    "                return i\n",
    "        return len(weight)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "        baket = 5000\n",
    "        ans = 0\n",
    "        for apple in weight:\n",
    "            baket -= apple\n",
    "            if baket >= 0:\n",
    "                ans += 1\n",
    "        return ans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        k = 5000\n",
    "        index = 0\n",
    "        n = len(weight)\n",
    "        weight.sort()\n",
    "        ret = 0\n",
    "        while (k >= 0) and (index < n):\n",
    "            if k >= weight[index]:\n",
    "                k -= weight[index]\n",
    "                index += 1\n",
    "                ret += 1\n",
    "            else:\n",
    "                break\n",
    "        return ret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "        s = 0\n",
    "        for i,num in enumerate(weight):\n",
    "            s += num\n",
    "            if s>5000:\n",
    "                return i\n",
    "        return len(weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "        res, n = 0, len(weight)\n",
    "        for i in range(n):\n",
    "            res += weight[i]\n",
    "            if res > 5000:\n",
    "                return i\n",
    "        return n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight = sorted(weight)\n",
    "        sum = 0\n",
    "        i = 0\n",
    "\n",
    "        while sum < 5000 and i < len(weight):\n",
    "            sum += weight[i]\n",
    "            i += 1\n",
    "\n",
    "        if sum > 5000:\n",
    "            return i - 1\n",
    "        else:\n",
    "            return i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        cnt = 0\n",
    "        limit = 5000\n",
    "        weight.sort()\n",
    "        for num in weight:\n",
    "            limit -= num\n",
    "            if limit >= 0:\n",
    "                cnt += 1\n",
    "            else:\n",
    "                break\n",
    "        return cnt\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "        ans = 0\n",
    "        pre = 5000\n",
    "        for w in weight:\n",
    "            if pre >= w:\n",
    "                pre -= w\n",
    "                ans += 1\n",
    "            else:\n",
    "                break\n",
    "        return ans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "\n",
    "        num = 0\n",
    "        res = 5000\n",
    "        for w in weight:\n",
    "            if w <= res:\n",
    "                res -= w\n",
    "                num += 1\n",
    "            else:\n",
    "                break\n",
    "        \n",
    "        return num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "        sum = 0\n",
    "        for i in range(len(weight)):\n",
    "            sum += weight[i]\n",
    "            if sum > 5000:\n",
    "                return i\n",
    "            elif sum == 5000:\n",
    "                return i + 1\n",
    "        else:\n",
    "            return len(weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, arr: List[int]) -> int:\n",
    "        sum = 0\n",
    "        count = 0\n",
    "        for i in sorted(arr):\n",
    "            sum += i\n",
    "            if sum > 5000:\n",
    "                break\n",
    "            count = count + 1\n",
    "        return count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight = sorted(weight)\n",
    "        sum = 0\n",
    "        i = 0\n",
    "\n",
    "        while sum < 5000 and i < len(weight):\n",
    "            sum += weight[i]\n",
    "            i += 1\n",
    "\n",
    "        if sum > 5000:\n",
    "            return i - 1\n",
    "        else:\n",
    "            return i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "        res = 0\n",
    "        for i in range(len(weight)):\n",
    "            res += weight[i]\n",
    "            if res > 5000:\n",
    "                return i\n",
    "        return len(weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "        res, cnt = 0, 0\n",
    "        for i in range(len(weight)):\n",
    "            res += weight[i]\n",
    "            cnt += 1\n",
    "            if res > 5000:\n",
    "                return cnt - 1\n",
    "        return cnt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "        res, cnt = 0, 0\n",
    "        for i in range(len(weight)):\n",
    "            res += weight[i]\n",
    "            cnt += 1\n",
    "            if res > 5000:\n",
    "                return cnt - 1\n",
    "        return cnt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort(reverse=0)\n",
    "        num = 0\n",
    "        w = 0\n",
    "        for i in range(0, len(weight)):\n",
    "            if w + weight[i] <= 5000:\n",
    "                num += 1\n",
    "                w += weight[i]\n",
    "            \n",
    "        return num\n",
    "\n",
    "            \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "        sum = 0\n",
    "        for i in range(len(weight)):\n",
    "            sum += weight[i]\n",
    "            if sum > 5000:\n",
    "                return i\n",
    "            elif sum == 5000:\n",
    "                return i + 1\n",
    "        else:\n",
    "            return len(weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "        ans = 0\n",
    "        usable_weight = 5000\n",
    "        for w in weight:\n",
    "            if usable_weight >= w:\n",
    "                ans += 1\n",
    "                usable_weight -= w\n",
    "        return ans"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "        sum = 0\n",
    "        for i in range(len(weight)):\n",
    "            sum += weight[i]\n",
    "            if sum > 5000:\n",
    "                return i\n",
    "            elif sum == 5000:\n",
    "                return i + 1\n",
    "        else:\n",
    "            return len(weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "import collections\n",
    "\n",
    "class Solution:\n",
    "    def maxNumberOfApples(self, weight: List[int]) -> int:\n",
    "        weight.sort()\n",
    "        SUM=0\n",
    "        count=0\n",
    "        print(weight)\n",
    "        for i in weight:\n",
    "            if SUM+i<=5000:\n",
    "                SUM+=i\n",
    "                count+=1\n",
    "                print(SUM)\n",
    "            else:\n",
    "                break\n",
    "        return count\n",
    "            "
   ]
  }
 ],
 "metadata": {},
 "nbformat": 4,
 "nbformat_minor": 2
}
